package sanrenxing.notice.dao.impl;

import sanrenxing.notice.dao.NoticeDao;
import sanrenxing.notice.domain.Notice;
import sanrenxing.notice.domain.NoticeTo;
import sanrenxing.utils.JdbcUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

/**
 * 功能:
 * 编写者:
 * 创建时间：2020/9/28 10:41
 * 版本:
 */
public class NoticeDaoImpl implements NoticeDao {
    /**
     * 将实体对象添加到数据库notice表中
     *
     * @param notice 对象
     * @return 成功添加的行数(1 : 添加成功 ; 0 : 添加失败)
     */
    @Override
    public int add(Notice notice) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="insert into notice(teacherId,noticeBody,classId,noticeBeginTime,noticeOutTime) values(?,?,?,?,?)";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,notice.getTeacherId());
            pstmt.setString(2,notice.getNoticeBody());
            pstmt.setInt(3,notice.getClassId());
            pstmt.setString(4,notice.getNoticeBeginTime());
            pstmt.setString(5,notice.getNoticeOutTime());
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 根据编号主键从数据库表中删除指定数据
     *
     * @param noticeId 编号主键
     * @return 删除影响的行数(1 : 删除成功 ; 0 : 删除失败)
     */
    @Override
    public int delete(int noticeId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="delete from notice where noticeId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,noticeId);
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 将对象数据修改到数据库表中
     *
     * @param notice 对象
     * @return 修改影响的行数(1 : 修改成功 ; 0 : 修改失败)
     */
    @Override
    public int update(Notice notice) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //定义影响行数的变量
        int rows=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="update notice set teacherId=?,noticeBody=?,classId=?," +
                    "noticeBeginTime=?,noticeOutTime=? where noticeId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,notice.getTeacherId());
            pstmt.setString(2,notice.getNoticeBody());
            pstmt.setInt(3,notice.getClassId());
            pstmt.setString(4,notice.getNoticeBeginTime());
            pstmt.setString(5,notice.getNoticeOutTime());
            pstmt.setInt(6,notice.getNoticeId());
            //使用预编译语句对象执行SQL语句，返回影响的行数
            rows=pstmt.executeUpdate();
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回影响的行数
        return rows;
    }

    /**
     * 根据编号主键从数据库表中查找单个员工
     *
     * @param noticeId 编号主键
     * @return 员工对象(如果返回null值 ， 表示查找失败)
     */
    @Override
    public Notice findById(int noticeId) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的员工对象
        Notice notice=null;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select noticeId,teacherId,noticeBody,classId,noticeBeginTime,noticeOutTime from notice where noticeId=?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //设置SQL语句中占位符赋值
            pstmt.setInt(1,noticeId);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //判断结果集，并把结果集的数据封装到员工对象中
            if(rs.next()){
                //实例化员工对象
                notice=new Notice();
                //把结果集数据赋值给员工对象各属性
                notice.setNoticeId(rs.getInt("noticeId"));
                notice.setTeacherId(rs.getInt("teacherId"));
                notice.setNoticeBody(rs.getString("noticeBody"));
                notice.setClassId(rs.getInt("classId"));
                notice.setNoticeBeginTime(rs.getString("noticeBeginTime"));
                notice.setNoticeOutTime(rs.getString("noticeOutTime"));
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回员工对象
        return notice;
    }

    /**
     * 查询数据库表中所有员工
     *
     * @return 对象集合
     */
    @Override
    public List<Notice> findAll() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的员工对象集合
        List<Notice> noticeList=new ArrayList<Notice>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select noticeId,teacherId,noticeBody,classId,noticeBeginTime," +
                    "noticeOutTime from notice";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到员工对象中
            while(rs.next()){
                //定义员工对象
                Notice notice=new Notice();
                //把结果集数据赋值给员工对象各属性
                notice.setNoticeId(rs.getInt("noticeId"));
                notice.setTeacherId(rs.getInt("teacherId"));
                notice.setNoticeBody(rs.getString("noticeBody"));
                notice.setClassId(rs.getInt("classId"));
                notice.setNoticeBeginTime(rs.getString("noticeBeginTime"));
                notice.setNoticeOutTime(rs.getString("noticeOutTime"));
                //把员工对象添加员工集合中
                noticeList.add(notice);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回员工对象集合
        return noticeList;
    }

    /**
     * 从数据库表中查询指定页的员工对象集合
     *
     * @param rows  每页的员工行数
     * @param pages 页数
     * @return 当前页的员工对象集合
     */
    @Override
    public List<Notice> findByPage(int rows, int pages) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的员工对象集合
        List<Notice> noticeList=new ArrayList<Notice>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select noticeId,teacherId,noticeBody,classId,noticeBeginTime," +
                    "noticeOutTime from notice limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到员工对象中
            while(rs.next()){
                //定义员工对象
                Notice notice=new Notice();
                //把结果集数据赋值给员工对象各属性
                notice.setNoticeId(rs.getInt("noticeId"));
                notice.setTeacherId(rs.getInt("teacherId"));
                notice.setNoticeBody(rs.getString("noticeBody"));
                notice.setClassId(rs.getInt("classId"));
                notice.setNoticeBeginTime(rs.getString("noticeBeginTime"));
                notice.setNoticeOutTime(rs.getString("noticeOutTime"));
                //把员工对象添加员工集合中
                noticeList.add(notice);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回员工对象集合
        return noticeList;
    }

    /**
     * 统计数据库emp表中记录总数
     *
     * @return 员工表中记录总数
     */
    @Override
    public int count() {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) as noticecount from notice";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                rowCount=rs.getInt("noticecount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 条件分页查询
     *
     * @param rows      每页行数
     * @param pages     页数
     * @param condition 条件
     * @return 员工对象集合
     */
    @Override
    public List<NoticeTo> findByPage(int rows, int pages, String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回的员工对象集合
        List<NoticeTo> noticeToList=new ArrayList<NoticeTo>();
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="SELECT n.noticeId,t.teacherName,n.noticeBody,cl.className,n.noticeBeginTime,n.noticeOutTime FROM notice n JOIN " +
                    "teacher t ON n.teacherId=t.teacherId JOIN " +
                    "class cl ON n.classId=cl.classId where 1=1 "+condition+" limit ?,?";
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //给分页语句占位符赋值
            //分页语句：select * from 表名 limits (pages-1)*rows,rows
            pstmt.setInt(1,(pages-1)*rows);
            pstmt.setInt(2,rows);
            //使用预编译语句对象执行SQL语句，返回结果集
            rs=pstmt.executeQuery();
            //循环判断结果集，并把结果集的数据封装到员工对象中
            while(rs.next()){
                //定义员工对象
                NoticeTo noticeTo=new NoticeTo();
                //把结果集数据赋值给员工对象各属性
                noticeTo.setNoticeId(rs.getInt("noticeId"));
                noticeTo.setTeacherName(rs.getString("teacherName"));
                noticeTo.setNoticeBody(rs.getString("noticeBody"));
                noticeTo.setClassName(rs.getString("className"));
                noticeTo.setNoticeBeginTime(rs.getString("noticeBeginTime"));
                noticeTo.setNoticeOutTime(rs.getString("noticeOutTime"));
                //把员工对象添加员工集合中
                noticeToList.add(noticeTo);
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        //返回员工对象集合
        return noticeToList;
    }

    /**
     * 条件统计
     *
     * @param condition 条件
     * @return 员工数
     */
    @Override
    public int count(String condition) {
        //声明数据库连接对象
        Connection conn=null;
        //声明预编译语句对象
        PreparedStatement pstmt=null;
        //声明结果集对象
        ResultSet rs=null;
        //定义返回表中总数据行数
        int rowCount=0;
        try {
            //实例化数据库连接对象
            conn= JdbcUtils.getConnection();
            //编写SQL语句字符串
            String sql="select count(*) as noticecount from notice n where 1=1 "+condition;
            //实例化预编译语句对象
            pstmt=conn.prepareStatement(sql);
            //使用预编译语句对象执行SQL语句，返回结果集合
            rs=pstmt.executeQuery();
            //判断结果集，并获得总行数
            if(rs.next()){
                //如果统计行数时没有指定别名，则用数字0作为参数
                rowCount=rs.getInt("noticecount");
            }
        } catch (SQLException e) {
            //抛出运行时异常
            throw new RuntimeException(e.getMessage(),e);
        } finally {
            //关闭/释放资源
            JdbcUtils.close(null,pstmt,conn);
        }
        //返回表中数据总行数
        return rowCount;
    }

    /**
     * 获取查询条件
     *
     * @param notice 对象
     * @return 条件字符串
     */
    @Override
    public String getCondition(Notice notice) {
        //定义查询条件字符串，初值为带空格的字符串(注意后续条件中的空格)
        String condition=" ";
        //如果员工对象为空，则直接返回空字符串
        if(notice==null){
            return condition;
        }
        //如果公告编号不为0
        if(notice.getNoticeId()!=0){
            condition += " n.and noticeId="+notice.getNoticeId();
        }
        //如果发布者编号不为0
        if(notice.getTeacherId()!=0){
            condition += " and n.teacherId="+notice.getTeacherId();
        }
        //如果公告内容不为空(字符串匹配模糊查询)
        if(notice.getNoticeBody()!=null && notice.getNoticeBody().trim().length()!=0){
            condition += " and n.noticeBody like '%"+notice.getNoticeBody()+"%' ";
        }
        //如果存在发送对象
        if(notice.getClassId()!=0){
            condition += " and n.classId="+notice.getClassId();
        }
        //如果存在显示公告日期
        if(notice.getNoticeBeginTime()!=null && notice.getNoticeBeginTime().trim().length()!=0){
            condition += " and n.noticeBeginTime like '%"+notice.getNoticeBeginTime()+"%' ";
        }
        //如果存在结束公告日期
        if(notice.getNoticeOutTime()!=null && notice.getNoticeOutTime().trim().length()!=0){
            condition += " and n.noticeOutTime like '%"+notice.getNoticeOutTime()+"%' ";
        }
        //返回条件字符串
        return condition;
    }

    /**
     * 通过班级名称查询班级编号
     *
     * @param className
     * @return
     */
    @Override
    public int findClassId(String className) {
        int classId;
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;


        try {
            conn= JdbcUtils.getConnection();
            String sql="SELECT  classId FROM class where className=? ";
            pstmt=conn.prepareStatement(sql);
            pstmt.setString(1,className);
            rs=pstmt.executeQuery();
            if (rs.next()){
                classId=rs.getInt("classId");
                return classId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }

    /**
     * 通过发布者名字查询发布者编号
     *
     * @param teacherName
     * @return
     */
    @Override
    public int findTeacherId(String teacherName) {
        int teacherId;
        Connection conn=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;


        try {
            conn= JdbcUtils.getConnection();
            String sql="SELECT  teacherId FROM teacher where teacherName=? ";
            pstmt=conn.prepareStatement(sql);
            pstmt.setString(1,teacherName);
            rs=pstmt.executeQuery();
            if (rs.next()){
                teacherId=rs.getInt("teacherId");
                return teacherId;
            }

        } catch (SQLException e) {
            throw new RuntimeException(e.getMessage(),e);
        }finally {
            //关闭/释放资源
            JdbcUtils.close(rs,pstmt,conn);
        }
        return 0;
    }
}
